home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / expread.y < prev    next >
Text File  |  1992-03-25  |  28KB  |  1,237 lines
  1. /* Parse C expressions for GDB.
  2.    Copyright (C) 1986 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. /* Parse a C expression from text in a string,
  22.    and return the result as a  struct expression  pointer.
  23.    That structure contains arithmetic operations in reverse polish,
  24.    with constants represented by operations that are followed by special data.
  25.    See expression.h for the details of the format.
  26.    What is important here is that it can be built up sequentially
  27.    during the process of parsing; the lower levels of the tree always
  28.    come first in the result.  */
  29.    
  30. %{
  31. #include "defs.h"
  32. #include "param.h"
  33. #include "symtab.h"
  34. #include "frame.h"
  35. #include "expression.h"
  36.  
  37. #include <stdio.h>
  38.  
  39. #ifdef atarist
  40. extern int gcc_mshort;
  41. #endif
  42.  
  43. extern CORE_ADDR end_of_text_addr;
  44. static struct expression *expout;
  45. static int expout_size;
  46. static int expout_ptr;
  47.  
  48. static int yylex ();
  49. static yyerror ();
  50. static void write_exp_elt ();
  51. static void write_exp_string ();
  52. static void start_arglist ();
  53. static int end_arglist ();
  54. static void free_funcalls ();
  55. static char *copy_name ();
  56.  
  57. /* If this is nonzero, this block is used as the lexical context
  58.    for symbol names.  */
  59.  
  60. static struct block *expression_context_block;
  61.  
  62. /* Number of arguments seen so far in innermost function call.  */
  63. static int arglist_len;
  64.  
  65. /* Data structure for saving values of arglist_len
  66.    for function calls whose arguments contain other function calls.  */
  67.  
  68. struct funcall
  69.   {
  70.     struct funcall *next;
  71.     int arglist_len;
  72.   };
  73.  
  74. struct funcall *funcall_chain;
  75.  
  76. /* This kind of datum is used to represent the name
  77.    of a symbol token.  */
  78.  
  79. struct stoken
  80.   {
  81.     char *ptr;
  82.     int length;
  83.   };
  84. %}
  85.  
  86. /* Although the yacc "value" of an expression is not used,
  87.    since the result is stored in the structure being created,
  88.    other node types do have values.  */
  89.  
  90. %union
  91.   {
  92.     long lval;
  93.     double dval;
  94.     struct symbol *sym;
  95.     struct type *tval;
  96.     struct stoken sval;
  97.     int voidval;
  98.     struct block *bval;
  99.     enum exp_opcode opcode;
  100.     struct internalvar *ivar;
  101.   }
  102.  
  103. %type <voidval> exp exp1 start variable
  104. %type <tval> type typebase
  105. %type <bval> block
  106.  
  107. %token <lval> INT CHAR
  108. %token <dval> FLOAT
  109.  
  110. /* Both NAME and TYPENAME tokens represent symbols in the input,
  111.    and both convey their data as strings.
  112.    But a TYPENAME is a string that happens to be defined as a typedef
  113.    or builtin type name (such as int or char)
  114.    and a NAME is any other symbol.
  115.  
  116.    Contexts where this distinction is not important can use the
  117.    nonterminal "name", which matches either NAME or TYPENAME.  */
  118.  
  119. %token <sval> NAME TYPENAME STRING
  120. %type <sval> name
  121.  
  122. %token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
  123.  
  124. %token <lval> LAST REGNAME
  125.  
  126. %token <ivar> VARIABLE
  127.  
  128. %token <opcode> ASSIGN_MODIFY
  129.  
  130. %left ','
  131. %left ABOVE_COMMA
  132. %right '=' ASSIGN_MODIFY
  133. %right '?'
  134. %left OR
  135. %left AND
  136. %left '|'
  137. %left '^'
  138. %left '&'
  139. %left EQUAL NOTEQUAL
  140. %left '<' '>' LEQ GEQ
  141. %left LSH RSH
  142. %left '+' '-'
  143. %left '*' '/' '%'
  144. %left '@'
  145. %right UNARY INCREMENT DECREMENT
  146. %right ARROW '.' '['
  147. %left COLONCOLON
  148.  
  149. %%
  150.  
  151. start   :    exp1
  152.     ;
  153.  
  154. /* Expressions, including the comma operator.  */
  155. exp1    :    exp
  156.     |    exp1 ',' exp
  157.             { write_exp_elt (BINOP_COMMA); }
  158.     ;
  159.  
  160. /* Expressions, not including the comma operator.  */
  161. exp    :    '*' exp    %prec UNARY
  162.             { write_exp_elt (UNOP_IND); }
  163.  
  164. exp    :    '&' exp    %prec UNARY
  165.             { write_exp_elt (UNOP_ADDR); }
  166.  
  167. exp    :    '-' exp    %prec UNARY
  168.             { write_exp_elt (UNOP_NEG); }
  169.     ;
  170.  
  171. exp    :    '!' exp    %prec UNARY
  172.             { write_exp_elt (UNOP_ZEROP); }
  173.     ;
  174.  
  175. exp    :    '~' exp    %prec UNARY
  176.             { write_exp_elt (UNOP_LOGNOT); }
  177.     ;
  178.  
  179. exp    :    INCREMENT exp    %prec UNARY
  180.             { write_exp_elt (UNOP_PREINCREMENT); }
  181.     ;
  182.  
  183. exp    :    DECREMENT exp    %prec UNARY
  184.             { write_exp_elt (UNOP_PREDECREMENT); }
  185.     ;
  186.  
  187. exp    :    exp INCREMENT    %prec UNARY
  188.             { write_exp_elt (UNOP_POSTINCREMENT); }
  189.     ;
  190.  
  191. exp    :    exp DECREMENT    %prec UNARY
  192.             { write_exp_elt (UNOP_POSTDECREMENT); }
  193.     ;
  194.  
  195. exp    :    SIZEOF exp       %prec UNARY
  196.             { write_exp_elt (UNOP_SIZEOF); }
  197.     ;
  198.  
  199. exp    :    exp ARROW name
  200.             { write_exp_elt (STRUCTOP_PTR);
  201.               write_exp_string ($3);
  202.               write_exp_elt (STRUCTOP_PTR); }
  203.     ;
  204.  
  205. exp    :    exp '.' name
  206.             { write_exp_elt (STRUCTOP_STRUCT);
  207.               write_exp_string ($3);
  208.               write_exp_elt (STRUCTOP_STRUCT); }
  209.     ;
  210.  
  211. exp    :    exp '[' exp1 ']'
  212.             { write_exp_elt (BINOP_SUBSCRIPT); }
  213.     ;
  214.  
  215. exp    :    exp '(' 
  216.             /* This is to save the value of arglist_len
  217.                being accumulated by an outer function call.  */
  218.             { start_arglist (); }
  219.         arglist ')'    %prec ARROW
  220.             { write_exp_elt (OP_FUNCALL);
  221.               write_exp_elt (end_arglist ());
  222.               write_exp_elt (OP_FUNCALL); }
  223.     ;
  224.  
  225. arglist    :
  226.     ;
  227.  
  228. arglist    :    exp
  229.             { arglist_len = 1; }
  230.     ;
  231.  
  232. arglist    :    arglist ',' exp   %prec ABOVE_COMMA
  233.             { arglist_len++; }
  234.     ;
  235.  
  236. exp    :    '{' type '}' exp  %prec UNARY
  237.             { write_exp_elt (UNOP_MEMVAL);
  238.               write_exp_elt ($2);
  239.               write_exp_elt (UNOP_MEMVAL); }
  240.     ;
  241.  
  242. exp    :    '(' type ')' exp  %prec UNARY
  243.             { write_exp_elt (UNOP_CAST);
  244.               write_exp_elt ($2);
  245.               write_exp_elt (UNOP_CAST); }
  246.     ;
  247.  
  248. exp    :    '(' exp1 ')'
  249.             { }
  250.     ;
  251.  
  252. /* Binary operators in order of decreasing precedence.  */
  253.  
  254. exp    :    exp '@' exp
  255.             { write_exp_elt (BINOP_REPEAT); }
  256.     ;
  257.  
  258. exp    :    exp '*' exp
  259.             { write_exp_elt (BINOP_MUL); }
  260.     ;
  261.  
  262. exp    :    exp '/' exp
  263.             { write_exp_elt (BINOP_DIV); }
  264.     ;
  265.  
  266. exp    :    exp '%' exp
  267.             { write_exp_elt (BINOP_REM); }
  268.     ;
  269.  
  270. exp    :    exp '+' exp
  271.             { write_exp_elt (BINOP_ADD); }
  272.     ;
  273.  
  274. exp    :    exp '-' exp
  275.             { write_exp_elt (BINOP_SUB); }
  276.     ;
  277.  
  278. exp    :    exp LSH exp
  279.             { write_exp_elt (BINOP_LSH); }
  280.     ;
  281.  
  282. exp    :    exp RSH exp
  283.             { write_exp_elt (BINOP_RSH); }
  284.     ;
  285.  
  286. exp    :    exp EQUAL exp
  287.             { write_exp_elt (BINOP_EQUAL); }
  288.     ;
  289.  
  290. exp    :    exp NOTEQUAL exp
  291.             { write_exp_elt (BINOP_NOTEQUAL); }
  292.     ;
  293.  
  294. exp    :    exp LEQ exp
  295.             { write_exp_elt (BINOP_LEQ); }
  296.     ;
  297.  
  298. exp    :    exp GEQ exp
  299.             { write_exp_elt (BINOP_GEQ); }
  300.     ;
  301.  
  302. exp    :    exp '<' exp
  303.             { write_exp_elt (BINOP_LESS); }
  304.     ;
  305.  
  306. exp    :    exp '>' exp
  307.             { write_exp_elt (BINOP_GTR); }
  308.     ;
  309.  
  310. exp    :    exp '&' exp
  311.             { write_exp_elt (BINOP_LOGAND); }
  312.     ;
  313.  
  314. exp    :    exp '^' exp
  315.             { write_exp_elt (BINOP_LOGXOR); }
  316.     ;
  317.  
  318. exp    :    exp '|' exp
  319.             { write_exp_elt (BINOP_LOGIOR); }
  320.     ;
  321.  
  322. exp    :    exp AND exp
  323.             { write_exp_elt (BINOP_AND); }
  324.     ;
  325.  
  326. exp    :    exp OR exp
  327.             { write_exp_elt (BINOP_OR); }
  328.     ;
  329.  
  330. exp    :    exp '?' exp ':' exp    %prec '?'
  331.             { write_exp_elt (TERNOP_COND); }
  332.     ;
  333.               
  334. exp    :    exp '=' exp
  335.             { write_exp_elt (BINOP_ASSIGN); }
  336.     ;
  337.  
  338. exp    :    exp ASSIGN_MODIFY exp
  339.             { write_exp_elt (BINOP_ASSIGN_MODIFY);
  340.               write_exp_elt ($2);
  341.               write_exp_elt (BINOP_ASSIGN_MODIFY); }
  342.     ;
  343.  
  344. exp    :    INT
  345.             { write_exp_elt (OP_LONG);
  346. #if 0
  347.               if(gcc_mshort)
  348.                   write_exp_elt (builtin_type_short);
  349.               else
  350. #endif
  351.               write_exp_elt (builtin_type_int);
  352.               write_exp_elt ($1);
  353.               write_exp_elt (OP_LONG); }
  354.     ;
  355.  
  356. exp    :    CHAR
  357.             { write_exp_elt (OP_LONG);
  358.               write_exp_elt (builtin_type_char);
  359.               write_exp_elt ($1);
  360.               write_exp_elt (OP_LONG); }
  361.     ;
  362.  
  363. exp    :    FLOAT
  364.             { write_exp_elt (OP_DOUBLE);
  365.               write_exp_elt (builtin_type_double);
  366.               write_exp_elt ($1);
  367.               write_exp_elt (OP_DOUBLE); }
  368.     ;
  369.  
  370. exp    :    variable
  371.     ;
  372.  
  373. exp    :    LAST
  374.             { write_exp_elt (OP_LAST);
  375.               write_exp_elt ($1);
  376.               write_exp_elt (OP_LAST); }
  377.     ;
  378.  
  379. exp    :    REGNAME
  380.             { write_exp_elt (OP_REGISTER);
  381.               write_exp_elt ($1);
  382.               write_exp_elt (OP_REGISTER); }
  383.     ;
  384.  
  385. exp    :    VARIABLE
  386.             { write_exp_elt (OP_INTERNALVAR);
  387.               write_exp_elt ($1);
  388.               write_exp_elt (OP_INTERNALVAR); }
  389.     ;
  390.  
  391. exp    :    SIZEOF '(' type ')'